home *** CD-ROM | disk | FTP | other *** search
/ Total Network Tools 2002 / NextStepPublishing-TotalNetworkTools2002-Win95.iso / Archive / Misc Servers / Zope.exe / PCGISERVER.PY < prev    next >
Encoding:
Python Source  |  1999-11-23  |  16.4 KB  |  459 lines
  1. ##############################################################################
  2. # 
  3. # Zope Public License (ZPL) Version 1.0
  4. # -------------------------------------
  5. # 
  6. # Copyright (c) Digital Creations.  All rights reserved.
  7. # 
  8. # This license has been certified as Open Source(tm).
  9. # 
  10. # Redistribution and use in source and binary forms, with or without
  11. # modification, are permitted provided that the following conditions are
  12. # met:
  13. # 
  14. # 1. Redistributions in source code must retain the above copyright
  15. #    notice, this list of conditions, and the following disclaimer.
  16. # 
  17. # 2. Redistributions in binary form must reproduce the above copyright
  18. #    notice, this list of conditions, and the following disclaimer in
  19. #    the documentation and/or other materials provided with the
  20. #    distribution.
  21. # 
  22. # 3. Digital Creations requests that attribution be given to Zope
  23. #    in any manner possible. Zope includes a "Powered by Zope"
  24. #    button that is installed by default. While it is not a license
  25. #    violation to remove this button, it is requested that the
  26. #    attribution remain. A significant investment has been put
  27. #    into Zope, and this effort will continue if the Zope community
  28. #    continues to grow. This is one way to assure that growth.
  29. # 
  30. # 4. All advertising materials and documentation mentioning
  31. #    features derived from or use of this software must display
  32. #    the following acknowledgement:
  33. # 
  34. #      "This product includes software developed by Digital Creations
  35. #      for use in the Z Object Publishing Environment
  36. #      (http://www.zope.org/)."
  37. # 
  38. #    In the event that the product being advertised includes an
  39. #    intact Zope distribution (with copyright and license included)
  40. #    then this clause is waived.
  41. # 
  42. # 5. Names associated with Zope or Digital Creations must not be used to
  43. #    endorse or promote products derived from this software without
  44. #    prior written permission from Digital Creations.
  45. # 
  46. # 6. Modified redistributions of any form whatsoever must retain
  47. #    the following acknowledgment:
  48. # 
  49. #      "This product includes software developed by Digital Creations
  50. #      for use in the Z Object Publishing Environment
  51. #      (http://www.zope.org/)."
  52. # 
  53. #    Intact (re-)distributions of any official Zope release do not
  54. #    require an external acknowledgement.
  55. # 
  56. # 7. Modifications are encouraged but must be packaged separately as
  57. #    patches to official Zope releases.  Distributions that do not
  58. #    clearly separate the patches from the original work must be clearly
  59. #    labeled as unofficial distributions.  Modifications which do not
  60. #    carry the name Zope may be packaged in any form, as long as they
  61. #    conform to all of the clauses above.
  62. # 
  63. # 
  64. # Disclaimer
  65. # 
  66. #   THIS SOFTWARE IS PROVIDED BY DIGITAL CREATIONS ``AS IS'' AND ANY
  67. #   EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  68. #   IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  69. #   PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL DIGITAL CREATIONS OR ITS
  70. #   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  71. #   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  72. #   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  73. #   USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  74. #   ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  75. #   OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  76. #   OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  77. #   SUCH DAMAGE.
  78. # 
  79. # 
  80. # This software consists of contributions made by Digital Creations and
  81. # many individuals on behalf of Digital Creations.  Specific
  82. # attributions are listed in the accompanying credits file.
  83. # 
  84. ##############################################################################
  85.  
  86. """
  87. Medusa PCGI server.
  88.  
  89. This server functions as the PCGI publisher--it accepts the request
  90. from the PCGI wrapper CGI program, services the request, and sends
  91. back the response.
  92.  
  93. It should work with both inet and unix domain sockets.
  94.  
  95. Why would you want to use it? Using PCGI to connect to ZServer from
  96. another webserver is similar to using the web server as a proxy,
  97. with the difference, that the web server gets to control the 
  98. environment and headers completely.
  99.  
  100. Note that ZServer can operate multiple PCGI servers.
  101. """
  102.  
  103. from medusa import asynchat, asyncore, logger
  104. from medusa.counter import counter
  105. from medusa.http_server import compute_timezone_for_log
  106. from medusa.asyncore import compact_traceback
  107.  
  108. from ZServer import CONNECTION_LIMIT
  109.  
  110. from PubCore import handle
  111. from PubCore.ZEvent import Wakeup
  112. from ZPublisher.HTTPResponse import HTTPResponse
  113. from ZPublisher.HTTPRequest import HTTPRequest
  114. from Producers import ShutdownProducer, LoggingProducer, CallbackProducer
  115. import DebugLogger
  116.  
  117. from cStringIO import StringIO
  118. from tempfile import TemporaryFile
  119. import socket, string, os, sys, time
  120. from types import StringType, TupleType
  121.  
  122. tz_for_log=compute_timezone_for_log()
  123.  
  124. class PCGIChannel(asynchat.async_chat):    
  125.     """Processes a PCGI request by collecting the env and stdin and
  126.     then passing them to ZPublisher. The result is wrapped in a
  127.     producer and sent back."""
  128.  
  129.     closed=0
  130.     
  131.     def __init__(self,server,sock,addr):
  132.         self.server = server
  133.         self.addr = addr
  134.         asynchat.async_chat.__init__ (self, sock)
  135.         self.env={}
  136.         self.data=StringIO()
  137.         self.set_terminator(10)
  138.         self.size=None
  139.         self.done=None
  140.         
  141.     def found_terminator(self):
  142.         if self.size is None:
  143.             # read the next size header
  144.             # and prepare to read env or stdin
  145.             self.data.seek(0)
  146.             self.size=string.atoi(self.data.read())
  147.             self.set_terminator(self.size)
  148.             if self.size==0:
  149.             
  150.                 DebugLogger.log('I', id(self), 0)
  151.             
  152.                 self.set_terminator('\r\n') 
  153.                 self.data=StringIO()
  154.                 self.send_response()
  155.             elif self.size > 1048576:
  156.                 self.data=TemporaryFile('w+b')
  157.             else:
  158.                 self.data=StringIO()
  159.         elif not self.env:
  160.             # read env
  161.             self.size=None
  162.             self.data.seek(0)
  163.             buff=self.data.read()
  164.             for line in string.split(buff,'\000'):
  165.                 try:
  166.                     k,v = string.split(line,'=',1)
  167.                     self.env[k] = v
  168.                 except:
  169.                     pass
  170.             # Hack around broken IIS PATH_INFO
  171.             # maybe, this should go in ZPublisher...      
  172.             if self.env.has_key('SERVER_SOFTWARE') and \
  173.                     string.find(self.env['SERVER_SOFTWARE'],
  174.                     'Microsoft-IIS') != -1:
  175.                 script = filter(None,string.split(
  176.                         string.strip(self.env['SCRIPT_NAME']),'/'))
  177.                 path = filter(None,string.split(
  178.                         string.strip(self.env['PATH_INFO']),'/'))
  179.                 self.env['PATH_INFO'] = '/' + string.join(path[len(script):],'/')
  180.             self.data=StringIO()
  181.  
  182.             DebugLogger.log('B', id(self), 
  183.                 '%s %s' % (self.env['REQUEST_METHOD'],
  184.                            self.env.get('PATH_INFO' ,'/')))
  185.                 
  186.             # now read the next size header
  187.             self.set_terminator(10)
  188.         else:
  189.  
  190.             DebugLogger.log('I', id(self), self.terminator)     
  191.         
  192.             # we're done, we've got both env and stdin
  193.             self.set_terminator('\r\n')
  194.             self.data.seek(0)
  195.             self.send_response()
  196.         
  197.     def send_response(self):
  198.         # create an output pipe by passing request to ZPublisher,
  199.         # and requesting a callback of self.log with the module
  200.         # name and PATH_INFO as an argument.
  201.         self.done=1        
  202.         response=PCGIResponse(stdout=PCGIPipe(self), stderr=StringIO())
  203.         request=HTTPRequest(self.data, self.env, response)
  204.         handle(self.server.module, request, response)
  205.         
  206.     def collect_incoming_data(self, data):
  207.         self.data.write(data)
  208.  
  209.     def readable(self):
  210.         if not self.done:
  211.             return 1
  212.      
  213.     def log_request(self, bytes):
  214.         if self.env.has_key('PATH_INFO'):
  215.             path=self.env['PATH_INFO']
  216.         else:
  217.             path='%s/' % self.server.module
  218.         if self.env.has_key('REQUEST_METHOD'):
  219.             method=self.env['REQUEST_METHOD']
  220.         else:
  221.             method="GET"
  222.         addr=self.addr
  223.         if addr and type(addr) is TupleType:
  224.             self.server.logger.log (
  225.                 addr[0],
  226.                 '%d - - [%s] "%s %s" %d %d' % (
  227.                     addr[1],
  228.                     time.strftime (
  229.                     '%d/%b/%Y:%H:%M:%S ',
  230.                     time.gmtime(time.time())
  231.                     ) + tz_for_log,
  232.                     method, path, self.reply_code, bytes
  233.                     )
  234.                 )
  235.         else:
  236.             self.server.logger.log (
  237.                 '127.0.0.1',
  238.                 '- - [%s] "%s %s" %d %d' % (
  239.                     time.strftime (
  240.                     '%d/%b/%Y:%H:%M:%S ',
  241.                     time.gmtime(time.time())
  242.                     ) + tz_for_log,
  243.                     method, path, self.reply_code, bytes
  244.                     )
  245.                 )       
  246.  
  247.     def push(self, producer, send=1):
  248.         # this is thread-safe when send is false
  249.         # note, that strings are not wrapped in 
  250.         # producers by default
  251.         self.producer_fifo.push(producer)
  252.         if send: self.initiate_send()
  253.         
  254.     def __repr__(self):
  255.         return "<PCGIChannel at %x>" % id(self)
  256.  
  257.     def close(self):
  258.         self.closed=1
  259.         while self.producer_fifo:
  260.             p=self.producer_fifo.first()
  261.             if p is not None and type(p) != StringType:
  262.                 p.more() # free up resources held by producer
  263.             self.producer_fifo.pop()
  264.         asyncore.dispatcher.close(self)          
  265.  
  266.  
  267. class PCGIServer(asyncore.dispatcher):
  268.     """Accepts PCGI requests and hands them off to the PCGIChannel for
  269.     handling.
  270.         
  271.     PCGIServer can be configured with either a PCGI info file or by
  272.     directly specifying the module, pid_file, and either port (for
  273.     inet sockets) or socket_file (for unix domain sockets.)
  274.  
  275.     For inet sockets, the ip argument specifies the address from which
  276.     the server will accept connections, '' indicates all addresses. If
  277.     you only want to accept connections from the localhost, set ip to
  278.     '127.0.0.1'."""
  279.         
  280.     channel_class=PCGIChannel
  281.  
  282.     def __init__ (self,
  283.             module='Main',
  284.             ip='127.0.0.1',
  285.             port=None,
  286.             socket_file=None,
  287.             pid_file=None,
  288.             pcgi_file=None,
  289.             resolver=None,
  290.             logger_object=None):
  291.  
  292.         self.ip = ip
  293.         asyncore.dispatcher.__init__(self)
  294.         self.count=counter()
  295.         if not logger_object:
  296.             logger_object = logger.file_logger (sys.stdout)
  297.         if resolver:
  298.             self.logger = logger.resolving_logger (resolver, logger_object)
  299.         else:
  300.             self.logger = logger.unresolving_logger (logger_object)
  301.         
  302.         # get configuration
  303.         self.module=module    
  304.         self.port=port
  305.         self.pid_file=pid_file
  306.         self.socket_file=socket_file
  307.         if pcgi_file is not None:
  308.             self.read_info(pcgi_file)
  309.         
  310.         # write pid file
  311.         try:
  312.            f = open(self.pid_file, 'w')
  313.            f.write(str(os.getpid()))
  314.            f.close()
  315.         except IOError:
  316.             self.log_info("Cannot write PID file.", 'error')
  317.         
  318.         # setup sockets
  319.         if self.port:
  320.             self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
  321.             self.set_reuse_addr()
  322.             self.bind((self.ip, self.port))
  323.             self.log_info(
  324.                 'PCGI Server started at %s\n'
  325.                 '\tInet socket port: %s' % (time.ctime(time.time()), self.port)
  326.                 )
  327.         else:
  328.             try:
  329.                 os.unlink(self.socket_file)
  330.             except os.error:
  331.                 pass
  332.             self.create_socket(socket.AF_UNIX, socket.SOCK_STREAM)
  333.             self.set_reuse_addr()
  334.             self.bind(self.socket_file)
  335.             try:
  336.                 os.chmod(self.socket_file,0777)
  337.             except os.error:
  338.                 pass
  339.             self.log_info(
  340.                 'PCGI Server started at %s\n' 
  341.                 '\tUnix socket: %s' % (time.ctime(time.time()), self.socket_file)
  342.                 )
  343.         self.listen(256)
  344.  
  345.  
  346.     def read_info(self,info_file):
  347.         "read configuration information from a PCGI info file"
  348.         lines=open(info_file).readlines()
  349.         directives={}
  350.         try:
  351.             for line in lines:
  352.                 line=string.strip(line)
  353.                 if not len(line) or line[0]=='#':
  354.                     continue
  355.                 k,v=string.split(line,'=',1)
  356.                 directives[string.strip(k)]=string.strip(v)
  357.         except:
  358.             raise 'ParseError', 'Error parsing PCGI info file'
  359.         
  360.         self.pid_file=directives.get('PCGI_PID_FILE',None)
  361.         self.socket_file=directives.get('PCGI_SOCKET_FILE',None)
  362.         if directives.has_key('PCGI_PORT'):
  363.             self.port=string.atoi(directives['PCGI_PORT'])
  364.         if directives.has_key('PCGI_MODULE'):
  365.             self.module=directives['PCGI_MODULE']
  366.         elif directives.has_key('PCGI_MODULE_PATH'):
  367.             path=directives['PCGI_MODULE_PATH']
  368.             path,module=os.path.split(path)
  369.             module,ext=os.path.splitext(module)
  370.             self.module=module
  371.         
  372.     def handle_accept (self):
  373.         self.count.increment()
  374.         try:
  375.             conn, addr = self.accept()
  376.         except socket.error:
  377.             self.log_info('Server accept() threw an exception', 'warning')
  378.             return
  379.         self.channel_class(self, conn, addr)
  380.    
  381.     def readable(self):
  382.         return len(asyncore.socket_map) < CONNECTION_LIMIT
  383.  
  384.     def writable (self):
  385.         return 0
  386.     
  387.     def listen(self, num):
  388.         # override asyncore limits for nt's listen queue size
  389.         self.accepting = 1
  390.         return self.socket.listen (num)
  391.         
  392.         
  393. class PCGIResponse(HTTPResponse):
  394.  
  395.     def write(self, data):
  396.         if not self._wrote:
  397.             self.stdout.write(str(self))
  398.             self._wrote=1
  399.         self.stdout.write(data)
  400.                                             
  401.     def _finish(self):
  402.         self.stdout.finish(self)
  403.         self.stdout.close()
  404.  
  405.         self.stdout=None
  406.         self._request=None
  407.         
  408.         
  409. class PCGIPipe:
  410.     """
  411.     Formats a HTTP response in PCGI format
  412.     
  413.         10 digits indicating len of STDOUT
  414.         STDOUT
  415.         10 digits indicating len of STDERR
  416.         STDERR
  417.     
  418.     Note that this implementation never sends STDERR
  419.     """
  420.     def __init__(self, channel):
  421.         self._channel=channel
  422.         self._data=StringIO()
  423.         self._shutdown=0
  424.     
  425.     def write(self,text):
  426.         self._data.write(text)
  427.         
  428.     def close(self):
  429.         if not self._channel.closed:
  430.             data=self._data.getvalue()
  431.             l=len(data)
  432.             DebugLogger.log('A', id(self._channel), 
  433.                 '%s %s' % (self._channel.reply_code, l))
  434.             self._channel.push('%010d%s%010d' % (l, data, 0), 0)
  435.             self._channel.push(LoggingProducer(self._channel, l, 'log_request'), 0)        
  436.             self._channel.push(CallbackProducer(
  437.                 lambda t=('E', id(self._channel)): apply(DebugLogger.log,t)), 0)
  438.  
  439.             if self._shutdown:
  440.                 try: r=self._shutdown[0]
  441.                 except: r=0
  442.                 sys.ZServerExitCode=r
  443.                 self._channel.push(ShutdownProducer(), 0)
  444.                 Wakeup(lambda: asyncore.close_all())
  445.             else:
  446.                 self._channel.push(None, 0)
  447.                 Wakeup()
  448.         self._data=None
  449.         self._channel=None
  450.         
  451.     def finish(self, response):
  452.         if response.headers.get('bobo-exception-type','') == \
  453.                 'exceptions.SystemExit':
  454.             r=response.headers.get('bobo-exception-value','0')
  455.             try: r=string.atoi(r)
  456.             except: r = r and 1 or 0
  457.             self._shutdown=r,
  458.         self._channel.reply_code=response.status
  459.